Pickle protokolini moslashtirish: __getstate__ va __setstate__ usullarini o'zlashtirish

Python-dagi pickle moduli ob'ektlarni seriyalashtirish va deserializatsiya qilishning kuchli usulini taqdim etadi. Bu ob'ektning holatini faylga yoki ma'lumotlar oqimiga saqlash va keyinchalik uni qayta tiklash imkonini beradi. Standart pickling xatti-harakati ko'pgina oddiy sinflar uchun yaxshi ishlagan bo'lsa-da, ko'proq murakkab ob'ektlar bilan ishlashda, ayniqsa to'g'ridan-to'g'ri seriyalashtirilishi mumkin bo'lmagan resurslarni, masalan, fayl tutqichlari, tarmoq ulanishlari yoki maxsus ishlov berishni talab qiladigan murakkab ma'lumotlar tuzilmalarini o'z ichiga olgan ob'ektlar bilan ishlashda moslashtirish juda muhim bo'lib qoladi. Aynan shu erda __getstate__ va __setstate__ usullari o'z o'rnini egallaydi. Ushbu maqola ushbu usullarning har tomonlama sharhini taqdim etadi va ulardan mustahkam ob'ektni seriyalashtirish va deserializatsiya qilish uchun qanday foydalanishni namoyish etadi.

Pickle protokolini tushunish

__getstate__ va __setstate__ ning o'ziga xosligiga sho'ng'ishdan oldin, pickle protokolining asoslarini tushunish muhimdir. Pickling, shuningdek, seriyalashtirish yoki ob'ektni saqlash deb ham ataladi, bu Python ob'ektini bayt oqimiga aylantirish jarayonidir. Unpickling, aksincha, ob'ektni bayt oqimidan qayta tiklash jarayonidir.

pickle moduli turli xil ob'ekt turlari va ma'lumotlarni ifodalash uchun bir qator opkodlardan foydalanadi. Keyin bu opkodlar ob'ektni qayta yaratish uchun unpickling paytida talqin qilinadi. Standart pickling xatti-harakati ko'pgina o'rnatilgan turlarni, masalan, butun sonlar, satrlar, ro'yxatlar, lug'atlar va kortejlarni avtomatik ravishda boshqaradi. Biroq, maxsus sinflar bilan ishlashda siz ko'pincha ob'ektning holati qanday saqlanishini va tiklanishini nazorat qilishingiz kerak.

Nega picklingni moslashtirish kerak?

Pickling jarayonini moslashtirishni istashingizning bir necha sabablari bor:

• Resurslarni boshqarish: Tashqi resurslarni (masalan, fayl tutqichlari, tarmoq ulanishlari) ushlab turuvchi ob'ektlar ko'pincha to'g'ridan-to'g'ri pickling qilinmaydi. Seriyalashtirish va deserializatsiya paytida siz bu resurslarni boshqarishingiz kerak.
• Unumdorlikni optimallashtirish: Pickling qilish uchun qaysi atributlarni tanlash orqali siz pickling qilingan ma'lumotlarning hajmini kamaytirishingiz va ishlashni yaxshilashingiz mumkin.
• Xavfsizlik muammolari: Ruxsatsiz kirishdan himoya qilish uchun siz sezgir ma'lumotlarni pickling qilinishidan chiqarib tashlashingiz mumkin.
• Versiya muvofiqligi: Picklingni moslashtirish sizga sinfingizning turli versiyalari o'rtasida muvofiqlikni saqlab qolish imkonini beradi.
• Ob'ektni qayta tiklash mantig'i: Murakkab ob'ektlar o'zlarining yaxlitligini ta'minlash uchun qayta tiklash paytida maxsus mantikni talab qilishi mumkin.

__getstate__ va __setstate__ ning roli

__getstate__ va __setstate__ usullari mos ravishda pickling va unpickling jarayonlarini moslashtirish uchun mexanizmni ta'minlaydi. Ushbu usullar ob'ekt pickling qilinganda qanday ma'lumotlar saqlanishini va ob'ekt unpickling qilinganda qanday qayta tiklanishini boshqarishga imkon beradi.

__getstate__ Usuli

__getstate__ usuli ob'ekt pickling qilinishidan oldin chaqiriladi. U nusxaning holatini ifodalovchi ob'ektni qaytarishi kerak. Ushbu holat ob'ekti asl ob'ekt o'rniga pickling qilinadi. Agar sinf __getstate__ ni aniqlasa, pickler uni pickling uchun ob'ektning holatini olish uchun chaqiradi. Agar aniqlanmagan bo'lsa, standart xatti-harakat ob'ektning __dict__ atributini pickling qilishdir, bu ob'ektning nusxa o'zgaruvchilarini o'z ichiga olgan lug'atdir.

Sintaksis:

            def __getstate__(self):
    # Ob'ektning holatini aniqlash uchun maxsus mantiq
    return state

            

              
                Copy
              
            
          

Misol:

Fayl tutqichini boshqaradigan sinfni ko'rib chiqing:

            class FileHandler:
    def __init__(self, filename):
        self.filename = filename
        self.file = open(filename, 'r+')

    def read(self):
        return self.file.read()

    def __getstate__(self):
        # Picklingdan oldin faylni yoping
        self.file.close()
        # Fayl nomini holat sifatida qaytaring
        return self.filename

    def __setstate__(self, filename):
        # Unpickling paytida fayl tutqichini tiklang
        self.filename = filename
        self.file = open(filename, 'r+')

    def __del__(self):
        # Ob'ekt axlat to'planganida fayl yopilganligiga ishonch hosil qiling
        if hasattr(self, 'file') and not self.file.closed:
            self.file.close()

            

              
                Copy
              
            
          

Ushbu misolda __getstate__ usuli fayl tutqichini yopadi va fayl nomini qaytaradi. Bu fayl tutqichi to'g'ridan-to'g'ri pickling qilinmasligini (bunda muvaffaqiyatsizlikka olib keladi) va unpickling paytida faylni qayta ochish mumkinligini ta'minlaydi.

__setstate__ Usuli

__setstate__ usuli ob'ekt unpickling qilinganda chaqiriladi. U __getstate__ tomonidan qaytarilgan holat ob'ektini (yoki __getstate__ aniqlanmagan bo'lsa, ob'ektning __dict__) qabul qiladi va ob'ektning holatini tiklash uchun javobgardir. Agar sinf __setstate__ ni aniqlasa, unpickler ob'ektning holatini tiklash uchun uni chaqiradi. Agar aniqlanmagan bo'lsa, unpickler holat ob'ektini to'g'ridan-to'g'ri ob'ektning __dict__ atributiga tayinlaydi.

Sintaksis:

            def __setstate__(self, state):
    # Ob'ektning holatini tiklash uchun maxsus mantiq
    pass

            

              
                Copy
              
            
          

Misol:

FileHandler sinfini davom ettirib, __setstate__ usuli fayl nomidan foydalanib fayl tutqichini qayta ochadi:

            class FileHandler:
    def __init__(self, filename):
        self.filename = filename
        self.file = open(filename, 'r+')

    def read(self):
        return self.file.read()

    def __getstate__(self):
        # Picklingdan oldin faylni yoping
        self.file.close()
        # Fayl nomini holat sifatida qaytaring
        return self.filename

    def __setstate__(self, filename):
        # Unpickling paytida fayl tutqichini tiklang
        self.filename = filename
        self.file = open(filename, 'r+')

    def __del__(self):
        # Ob'ekt axlat to'planganida fayl yopilganligiga ishonch hosil qiling
        if hasattr(self, 'file') and not self.file.closed:
            self.file.close()

            

              
                Copy
              
            
          

Ushbu misolda __setstate__ usuli fayl nomini qabul qiladi va faylni o'qish-yozish rejimida qayta ochadi. Bu ob'ekt unpickling qilinganda fayl tutqichi to'g'ri tiklanishini ta'minlaydi.

Amaliy misollar va foydalanish holatlari

__getstate__ va __setstate__ picklingni qanday moslashtirish uchun ishlatilishi mumkinligining ba'zi amaliy misollarini ko'rib chiqaylik.

Misol 1: Tarmoq ulanishlarini boshqarish

Tarmoq ulanishini boshqaradigan sinfni ko'rib chiqing:

            import socket

class NetworkClient:
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.connect((host, port))

    def send(self, message):
        self.socket.sendall(message.encode())

    def receive(self):
        return self.socket.recv(1024).decode()

    def __getstate__(self):
        # Picklingdan oldin soketni yoping
        self.socket.close()
        # Host va portni holat sifatida qaytaring
        return (self.host, self.port)

    def __setstate__(self, state):
        # Unpickling paytida soket ulanishini tiklang
        self.host, self.port = state
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.connect((self.host, self.port))

    def __del__(self):
        # Ob'ekt axlat to'planganida soket yopilganligiga ishonch hosil qiling
        if hasattr(self, 'socket'):
            self.socket.close()

            

              
                Copy
              
            
          

Ushbu misolda __getstate__ usuli soket ulanishini yopadi va host va portni qaytaradi. __setstate__ usuli ob'ekt unpickling qilinganda soket ulanishini qayta tiklaydi.

Misol 2: Sezgir ma'lumotlarni istisno qilish

Sizda parol kabi sezgir ma'lumotlarni o'z ichiga olgan sinf bor deb faraz qiling. Siz bu ma'lumotlarni pickling qilinishidan chiqarib tashlamoqchi bo'lishingiz mumkin:

            class UserProfile:
    def __init__(self, username, password, email):
        self.username = username
        self.password = password  # Sezgir ma'lumotlar
        self.email = email

    def __getstate__(self):
        # Faqat username va emailni o'z ichiga olgan lug'atni qaytarish
        return {'username': self.username, 'email': self.email}

    def __setstate__(self, state):
        # Username va emailni tiklash
        self.username = state['username']
        self.email = state['email']
        # Parol tiklanmaydi (xavfsizlik sabablari bilan)
        self.password = None

            

              
                Copy
              
            
          

Ushbu misolda __getstate__ usuli faqat username va emailni o'z ichiga olgan lug'atni qaytaradi. __setstate__ usuli ushbu atributlarni tiklaydi, lekin parolni None ga o'rnatadi. Bu parol pickling qilingan ma'lumotlarda saqlanmasligini ta'minlaydi.

Misol 3: Murakkab ma'lumotlar tuzilmalarini boshqarish

Daraxt kabi murakkab ma'lumotlar tuzilmasini boshqaradigan sinfni ko'rib chiqing. Daraxtning yaxlitligini saqlab qolish uchun pickling va unpickling paytida maxsus operatsiyalarni bajarishingiz kerak bo'lishi mumkin:

            class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

    def add_child(self, child):
        self.children.append(child)

class Tree:
    def __init__(self, root):
        self.root = root

    def __getstate__(self):
        # Daraxt tuzilishini qiymatlar va ota indekslar ro'yxatiga seriyalashtirish
        nodes = []
        parent_indices = []
        node_map = {}

        def traverse(node, parent_index):
            index = len(nodes)
            nodes.append(node.value)
            parent_indices.append(parent_index)
            node_map[node] = index
            for child in node.children:
                traverse(child, index)

        traverse(self.root, -1)
        return {'nodes': nodes, 'parent_indices': parent_indices}

    def __setstate__(self, state):
        # Daraxtni seriyalashtirilgan ma'lumotlardan qayta tiklash
        nodes = state['nodes']
        parent_indices = state['parent_indices']
        node_objects = [TreeNode(value) for value in nodes]
        self.root = node_objects[0]

        for i, parent_index in enumerate(parent_indices):
            if parent_index != -1:
                node_objects[parent_index].add_child(node_objects[i])

# Misoldan foydalanish:
root = TreeNode('A')
child1 = TreeNode('B')
child2 = TreeNode('C')
root.add_child(child1)
root.add_child(child2)

tree = Tree(root)

import pickle

# Daraxtni pickling qiling
with open('tree.pkl', 'wb') as f:
    pickle.dump(tree, f)

# Daraxtni unpickling qiling
with open('tree.pkl', 'rb') as f:
    loaded_tree = pickle.load(f)

# Daraxt tuzilishi saqlanganligini tekshiring
print(loaded_tree.root.value)  # Output: A
print(loaded_tree.root.children[0].value) # Output: B

            

              
                Copy
              
            
          

Ushbu misolda __getstate__ usuli daraxt tuzilishini tugun qiymatlari va ota indekslarining ro'yxatiga seriyalashtiradi. __setstate__ usuli daraxtni ushbu seriyalashtirilgan ma'lumotlardan qayta tiklaydi. Ushbu yondashuv murakkab daraxt tuzilmalarini samarali pickling va unpickling qilish imkonini beradi.

Eng yaxshi amaliyotlar va mulohazalar

• Har doim __getstate__ ichidagi resurslarni yoping: Agar ob'ektingiz tashqi resurslarni (masalan, fayl tutqichlari, tarmoq ulanishlari) ushlab tursa, resurslar oqishini oldini olish uchun ularni __getstate__ usulida yoping.
• __setstate__ ichidagi resurslarni tiklang: __getstate__ da yopilgan har qanday resurslarni __setstate__ usulida qayta oching yoki qayta tiklang.
• Istisnolarni oqilona boshqaring: Istisnolarni oqilona boshqarishni ta'minlash uchun __getstate__ va __setstate__ da tegishli xatolarni boshqarishni amalga oshiring.
• Versiyani mosligini ko'rib chiqing: Agar sizning sinfingiz vaqt o'tishi bilan rivojlanishi ehtimoli bo'lsa, __getstate__ va __setstate__ usullarini eski versiyalar bilan orqaga muvofiq bo'lish uchun loyihalashtiring. Bu pickling qilingan ma'lumotlarga versiya ma'lumotini qo'shishni o'z ichiga olishi mumkin.
• Unumdorlik uchun __slots__ ni ishlating: Agar sizning sinfingiz belgilangan atributlarga ega bo'lsa, xotira hajmini kamaytirish va unumdorlikni yaxshilash uchun __slots__ dan foydalanishni ko'rib chiqing. __slots__ dan foydalanganda, ob'ektning holatini to'g'ri boshqarish uchun __getstate__ va __setstate__ ni moslashtirishingiz kerak bo'lishi mumkin.
• Moslashtirishni hujjatlashtiring: Boshqa ishlab chiquvchilar sinfingiz qanday seriyalashtirilganligi va deserializatsiya qilinganligini tushunishi uchun maxsus pickling xatti-harakatingizni aniq hujjatlashtiring.
• Pickling mantig'ingizni sinab ko'ring: Ob'ektlaringizning to'g'ri seriyalashtirilganligini va deserializatsiya qilinganligini ta'minlash uchun pickling va unpickling mantig'ingizni sinchkovlik bilan sinab ko'ring.

Pickle protokoli versiyalari

pickle moduli turli xil protokol versiyalarini qo'llab-quvvatlaydi, ularning har biri o'ziga xos xususiyatlar va cheklovlarga ega. Protokol versiyasi pickling qilingan ma'lumotlarning formatini aniqlaydi. Odatda, yuqori protokol versiyalari yaxshi ishlashni va ko'proq ob'ekt turlarini qo'llab-quvvatlaydi.

Protokol versiyasini belgilash uchun pickle.dump() funktsiyasining protocol argumentidan foydalaning:

            import pickle

# Protokol versiyasi 4 dan foydalaning (Python 3 uchun tavsiya etiladi)
with open('data.pkl', 'wb') as f:
    pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)

            

              
                Copy
              
            
          

Mavjud protokol versiyalarining qisqacha ko'rinishi:

• Protokol 0: Asl odam o'qiy oladigan protokol. U sekin va cheklangan funksionallikka ega.
• Protokol 1: Eskiroq ikkilik protokol.
• Protokol 2: Python 2.3 da taqdim etilgan. U 0 va 1 protokollariga qaraganda yaxshiroq ishlashni ta'minlaydi.
• Protokol 3: Python 3.0 da taqdim etilgan. U bytes ob'ektlarini qo'llab-quvvatlaydi va 2-protokoldan samaraliroq.
• Protokol 4: Python 3.4 da taqdim etilgan. U juda katta ob'ektlarni, sinflarni havola bilan pickling qilishni va ba'zi ma'lumot formatlarini optimallashtirishni qo'llab-quvvatlashni qo'shadi. Bu odatda Python 3 uchun tavsiya etilgan protokol.
• Protokol 5: Python 3.8 da taqdim etilgan. O'rnatilgan ma'lumotlarni va kichik butun sonlar va suzuvchi sonlarni tezroq pickling qilishni qo'llab-quvvatlashni qo'shadi.

pickle.HIGHEST_PROTOCOL dan foydalanish sizning Python versiyangiz uchun mavjud bo'lgan eng samarali protokoldan foydalanayotganingizga ishonch hosil qiladi. Protokol versiyasini tanlashda har doim ilovangizning muvofiqlik talablarini ko'rib chiqing.

Pickle uchun alternativlar

pickle Python ob'ektlarini seriyalashtirishning qulay usuli bo'lsa-da, uning ba'zi cheklovlari va xavfsizlik muammolari mavjud. E'tiborga olish kerak bo'lgan ba'zi alternativlar:

• JSON: JSON (JavaScript Object Notation) veb-ilovalarida keng qo'llaniladigan yengil ma'lumot almashish formatidir. U odam o'qishi mumkin va ko'plab dasturlash tillari tomonidan qo'llab-quvvatlanadi. Biroq, JSON faqat asosiy ma'lumot turlarini (masalan, satrlar, raqamlar, mantiqiy qiymatlar, ro'yxatlar, lug'atlar) qo'llab-quvvatlaydi va ixtiyoriy Python ob'ektlarini seriyalashtira olmaydi.
• Marshal: marshal moduli pickle ga o'xshash, ammo asosan Python tomonidan ichki foydalanish uchun mo'ljallangan. U pickle ga qaraganda tezroq, ammo kamroq ko'p qirrali va turli Python versiyalari o'rtasida muvofiqligi kafolatlanmagan.
• Shelve: shelve moduli lug'atga o'xshash interfeys yordamida Python ob'ektlari uchun doimiy saqlashni ta'minlaydi. U ob'ektlarni seriyalashtirish uchun pickle dan foydalanadi va ularni ma'lumotlar bazasi faylida saqlaydi.
• MessagePack: MessagePack JSON ga qaraganda samaraliroq bo'lgan ikkilik seriyalashtirish formatidir. U ma'lumotlarning kengroq turlarini qo'llab-quvvatlaydi va ko'plab dasturlash tillari uchun mavjud.
• Protokol buferlari: Protokol buferlari (protobuf) - bu tuzilgan ma'lumotlarni seriyalashtirish uchun til-neytral, platforma-neytral kengaytiriladigan mexanizmdir. U pickle ga qaraganda murakkabroq, ammo yaxshiroq ishlashni va sxemani evolyutsiyalash imkoniyatlarini taklif qiladi.
• Apache Avro: Apache Avro - boy ma'lumotlar tuzilmalarini, ixcham ikkilik ma'lumotlar formatini va samarali ma'lumotlarni qayta ishlashni ta'minlaydigan ma'lumotlarni seriyalashtirish tizimi. U ko'pincha katta ma'lumotlar ilovalarida ishlatiladi.

Seriyalashtirish usulini tanlash ilovangizning o'ziga xos talablariga bog'liq. Unumdorlik, xavfsizlik, muvofiqlik va seriyalashtirish kerak bo'lgan ma'lumotlar tuzilmalarining murakkabligi kabi omillarni ko'rib chiqing.

Xavfsizlik nuqtai nazardan

Ishonchli bo'lmagan manbalardan ma'lumotlarni unpickling qilish bilan bog'liq xavfsizlik xavfidan xabardor bo'lish juda muhimdir. Zararli ma'lumotlarni unpickling qilish ixtiyoriy kodni bajarilishiga olib kelishi mumkin. Hech qachon ishonchli bo'lmagan manbadan ma'lumotlarni unpickling qilmang.

Picklingning xavfsizlik xavfini kamaytirish uchun quyidagi eng yaxshi amaliyotlarni ko'rib chiqing:

• Faqat ishonchli manbalardan ma'lumotlarni unpickling qiling: Hech qachon ishonchli bo'lmagan yoki noma'lum manbalardan ma'lumotlarni unpickling qilmang.
• Xavfsiz alternativadan foydalaning: Agar iloji bo'lsa, pickle o'rniga JSON yoki Protokol buferlari kabi xavfsiz seriyalashtirish formatidan foydalaning.
• Pickling qilingan ma'lumotlaringizni imzolang: Pickling qilingan ma'lumotlaringizning yaxlitligini va haqiqiyligini tekshirish uchun kriptografik imzo ishlatish.
• Unpickling ruxsatlarini cheklang: Zararli ma'lumotlardan kelib chiqadigan potentsial zararni minimallashtirish uchun unpickling kodingizni cheklangan ruxsatlar bilan ishga tushiring.
• Pickling kodingizni audit qiling: Potentsial xavfsizlik zaifliklarini aniqlash va tuzatish uchun pickling va unpickling kodingizni muntazam ravishda audit qiling.

Xulosa

__getstate__ va __setstate__ yordamida pickling jarayonini moslashtirish Python-da ob'ektni seriyalashtirish va deserializatsiyasini boshqarishning kuchli usulini taqdim etadi. Ushbu usullarni tushunib va eng yaxshi amaliyotlarga rioya qilib, siz ob'ektlaringiz murakkab ma'lumotlar tuzilmalari, tashqi resurslar yoki xavfsizlikka sezgir ma'lumotlar bilan ishlashda ham to'g'ri pickling va unpickling qilinishini ta'minlashingiz mumkin. Biroq, har doim xavfsizlik oqibatlariga e'tibor bering va tegishli bo'lganda muqobil seriyalashtirish usullarini ko'rib chiqing. Seriyalashtirish texnikasini tanlash loyihaning xavfsizlik talablariga, unumdorlik maqsadlariga va ma'lumotlarning murakkabligiga mos kelishi kerak, bu esa mustahkam va xavfsiz ilovani ta'minlaydi.

Ushbu usullarni o'zlashtirish va seriyalashtirish variantlarining kengroq manzarasini tushunish orqali ishlab chiquvchilar ob'ektni saqlash va ma'lumotlarni saqlashni samarali boshqaradigan, yanada mustahkam, xavfsiz va samarali Python ilovalarini yaratishlari mumkin.